vendor/plugins/rubyzip-0.9.1/lib/quiz1/t/solutions/Moses Hohman/test_deck.rb

   1 #!/usr/bin/env ruby
   2 require 'test/unit'
   3 require 'deck'
   4
   5 module Solitaire
   6         class TestDeck < Test::Unit::TestCase
   7                 def test_constructor_accepts_ranges_in_array
   8                         assert_equal(Deck.new, Deck.new([1, 2, 3, 4..52, 53..54]))
   9                 end
  10
  11                 def test_construcor_accepts_chars_for_jokers
  12                         assert_equal(Deck.new, Deck.new((1..52).to_a + [?A, ?B]))
  13                 end
  14
  15                 def test_move_card_lower
  16                         deck = Deck.new
  17                         deck.move_card!(Card.new(Suit::DIAMONDS, 6), +5)
  18                         assert_equal(Deck.new([1..18,20..24,19,25..54]).to_s, deck.to_s)
  19                 end
  20
  21                 def test_move_card_one_lower
  22                         deck = Deck.new
  23                         deck.move_card!(Card.new(Suit::DIAMONDS, 6), +1)
  24                         assert_equal(Deck.new([1..18,20,19,21..54]).to_s, deck.to_s)
  25                 end
  26
  27                 def test_move_card_higher
  28                         deck = Deck.new
  29                         deck.move_card!(Card.new(Suit::DIAMONDS, 6), -5)
  30                         assert_equal(Deck.new([1..13,19,14..18,20..54]), deck)
  31                 end
  32
  33                 def test_move_card_is_cyclic_plus_1
  34                         deck = Deck.new
  35                         deck.move_card!(Card.joker(?A), +2)
  36                         assert_equal(Deck.new([1,53,2..52,54]), deck)
  37                 end
  38
  39                 def test_move_card_to_end
  40                         deck = Deck.new
  41                         deck.move_card!(Card.joker(?A), +1)
  42                         assert_equal(Deck.new([1..52,54,53]), deck)
  43                 end
  44
  45                 def test_move_card_to_one_before_end
  46                         deck = Deck.new([2..54,1])
  47                         deck.move_card!(Card.joker(?A), +1)
  48                         assert_equal(Deck.new([2..52,54,53,1]).to_s, deck.to_s)
  49                 end
  50
  51                 def test_move_card_to_beginning
  52                         deck = Deck.new
  53                         deck.move_card!(Card.new(Suit::CLUBS, 2), -1)
  54                         assert_equal(Deck.new([2,1,3..54]), deck)
  55                 end
  56
  57                 def test_move_card_is_cyclic_pass_end_forward
  58                         deck = Deck.new
  59                         deck.move_card!(Card.joker(?B), +1)
  60                         assert_equal(Deck.new([1,54,2..53]), deck)
  61                 end
  62
  63                 def test_move_card_is_cyclic_pass_end_backward
  64                         deck = Deck.new
  65                         deck.move_card!(Card.new(Suit::CLUBS, Card::ACE), -1)
  66                         assert_equal(Deck.new([2..53,1,54]), deck)
  67                 end
  68
  69                 def test_move_card_cyclic_backward_five
  70                         deck = Deck.new
  71                         deck.move_card!(Card.new(Suit::CLUBS, 5), -5)
  72                         assert_equal(Deck.new([1..4,6..53,5,54]), deck)
  73                 end
  74
  75                 def test_triple_cut
  76                         deck = Deck.new
  77                         deck.triple_cut!([Card.new(Suit::CLUBS, Card::JACK), Card.new(Suit::HEARTS, Card::KING)])
  78                         assert_equal(Deck.new([40..54,11..39,1..10]), deck)
  79                 end
  80
  81                 def test_triple_cut_with_empty_side
  82                         deck = Deck.new([2..53,1,54])
  83                         deck.triple_cut!([Card.joker(?A), Card.joker(?B)])
  84                         assert_equal(Deck.new([53,1,54,2..52]), deck)
  85                 end
  86
  87                 def test_count_cut
  88                         deck = Deck.new
  89                         deck.move_card!(Card.new(Suit::CLUBS, 5), 49)
  90                         deck.count_cut!
  91                         assert_equal(Deck.new([7..54,1..4,6,5]), deck)
  92                 end
  93         end
  94
  95         class TestCard < Test::Unit::TestCase
  96                 def test_parse_joker_string
  97                         assert_equal(Card.joker(?A), Card.parse("A"))
  98                 end
  99
 100                 def test_parse_joker_char
 101                         assert_equal(Card.joker(?A), Card.parse(?A))
 102                 end
 103
 104                 def test_parse_normal_card
 105                         assert_equal(Card.new(Suit::CLUBS, 5), Card.parse(5))
 106                 end
 107
 108                 def test_value
 109                         assert_equal(1, Card.new(Suit::CLUBS, Card::ACE).value, "AC")
 110                         assert_equal(7, Card.new(Suit::CLUBS, 7).value, "7C")
 111                         assert_equal(11, Card.new(Suit::CLUBS, Card::JACK).value, "JC")
 112                         assert_equal(13, Card.new(Suit::CLUBS, Card::KING).value, "KC")
 113                         assert_equal(14, Card.new(Suit::DIAMONDS, Card::ACE).value, "AD")
 114                         assert_equal(26, Card.new(Suit::DIAMONDS, Card::KING).value, "KD")
 115                         assert_equal(29, Card.new(Suit::HEARTS, 3).value, "3H")
 116                         assert_equal(39, Card.new(Suit::HEARTS, Card::KING).value, "KH")
 117                         assert_equal(40, Card.new(Suit::SPADES, Card::ACE).value, "AS")
 118                         assert_equal(52, Card.new(Suit::SPADES, Card::KING).value, "KS")
 119                         assert_equal(53, Card.joker(?A).value, "A Joker")
 120                         assert_equal(53, Card.joker(?B).value, "B Joker")
 121                 end
 122
 123                 def test_is_joker_when_joker
 124                         assert(Card.joker(?A).is_joker?, "A joker not joker")
 125                         assert(Card.joker(?B).is_joker?, "B joker not joker")
 126                 end
 127
 128                 def test_is_joker_when_not_joker
 129                         assert(!Card.new(Suit::SPADES, 7).is_joker?)
 130                 end
 131         end
 132
 133         class TestSuit < Test::Unit::TestCase
 134                 def test_by_value_clubs
 135                         assert_equal("clubs", Suit.by_value(1).name)
 136                 end
 137
 138                 def test_by_value_hearts
 139                         assert_equal("hearts", Suit.by_value(27).name)
 140                 end
 141
 142                 def test_hearts
 143                         assert_equal("hearts", Suit::HEARTS.name)
 144                 end
 145         end
 146 end